package com.adf.gencode;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Predicate;
import java.util.stream.Stream;

/**
 * 全局静态列表管理器（支持多 key 隔离，线程安全）
 * 不同 key 对应独立的列表，同一 key 下的列表元素类型由泛型 T 约束
 */
public class GlobalList<T> {
    // 全局容器：key -> 对应列表实例（线程安全的 ConcurrentHashMap）
    private static final Map<String, GlobalList<?>> GLOBAL_LISTS = new ConcurrentHashMap<>();

    // 当前 key 对应的线程安全列表（读多写少场景优化，使用 CopyOnWriteArrayList）
    private final List<T> list = new CopyOnWriteArrayList<>();

    // 私有构造器：禁止外部直接实例化，必须通过 getInstance 获取
    private GlobalList() {}

    /**
     * 根据 key 获取全局列表实例（核心方法）
     * 相同 key 返回同一个实例，不同 key 返回独立实例；线程安全
     * @param key 列表唯一标识（非 null/空）
     * @return 对应 key 的全局列表实例
     */
    @SuppressWarnings("unchecked")
    public static <T> GlobalList<T> getInstance(String key) {
        // 校验 key 合法性
        if (key == null || key.trim().isEmpty()) {
            throw new IllegalArgumentException("全局列表 key 不能为空或空白");
        }
        // 若 key 不存在则创建新实例，computeIfAbsent 保证线程安全
        return (GlobalList<T>) GLOBAL_LISTS.computeIfAbsent(key, k -> new GlobalList<>());
    }

    // ------------------------------ 基础元素操作 ------------------------------

    /**
     * 添加元素到列表（线程安全）
     * @param element 要添加的元素（可为 null）
     * @return 添加成功返回 true（CopyOnWriteArrayList 始终返回 true）
     */
    public boolean add(T element) {
        return list.add(element);
    }

    /**
     * 在指定索引插入元素（线程安全）
     * @param index 插入位置
     * @param element 要插入的元素
     * @throws IndexOutOfBoundsException 索引越界时抛出
     */
    public void add(int index, T element) {
        list.add(index, element);
    }

    /**
     * 批量添加元素（线程安全）
     * @param elements 待添加的元素集合
     * @return 集合非空且添加成功时返回 true
     */
    public boolean addAll(Collection<? extends T> elements) {
        return elements != null && list.addAll(elements);
    }

    /**
     * 获取指定索引的元素（线程安全）
     * @param index 元素索引
     * @return 对应位置的元素
     * @throws IndexOutOfBoundsException 索引越界时抛出
     */
    public T get(int index) {
        return list.get(index);
    }

    /**
     * 替换指定索引的元素（线程安全）
     * @param index 替换位置
     * @param element 新元素
     * @return 被替换的旧元素
     * @throws IndexOutOfBoundsException 索引越界时抛出
     */
    public T set(int index, T element) {
        return list.set(index, element);
    }

    /**
     * 移除指定元素（线程安全，仅移除第一个匹配项）
     * @param element 要移除的元素
     * @return 元素存在且被移除时返回 true
     */
    public boolean remove(Object element) {
        return list.remove(element);
    }

    /**
     * 移除指定索引的元素（线程安全）
     * @param index 要移除的位置
     * @return 被移除的元素
     * @throws IndexOutOfBoundsException 索引越界时抛出
     */
    public T remove(int index) {
        return list.remove(index);
    }

    /**
     * 移除所有符合条件的元素（线程安全）
     * @param filter 过滤条件（Predicate）
     * @return 有元素被移除时返回 true
     */
    public boolean removeIf(Predicate<? super T> filter) {
        return list.removeIf(filter);
    }

    // ------------------------------ 列表状态操作 ------------------------------

    /**
     * 清空列表所有元素（线程安全，保留列表实例）
     */
    public void clear() {
        list.clear();
    }

    /**
     * 检查列表是否包含指定元素（线程安全）
     * @param element 待检查元素
     * @return 存在返回 true
     */
    public boolean contains(Object element) {
        return list.contains(element);
    }

    /**
     * 获取列表元素数量（线程安全）
     * @return 列表大小
     */
    public int size() {
        return list.size();
    }

    /**
     * 检查列表是否为空（线程安全）
     * @return 空列表返回 true
     */
    public boolean isEmpty() {
        return list.isEmpty();
    }

    // ------------------------------ 高级查询与转换 ------------------------------

    /**
     * 查找第一个符合条件的元素（线程安全）
     * @param filter 过滤条件
     * @return 包含元素的 Optional（无匹配时为空）
     */
    public Optional<T> findFirst(Predicate<? super T> filter) {
        return list.stream().filter(filter).findFirst();
    }

    /**
     * 查找所有符合条件的元素（线程安全）
     * @param filter 过滤条件
     * @return 匹配元素的新列表（不可修改）
     */
    public List<T> findAll(Predicate<? super T> filter) {
        return list.stream().filter(filter).toList(); // toList() 返回不可修改列表
    }

    /**
     * 获取列表的流式处理对象（线程安全，基于当前快照）
     * @return 元素流（Stream<T>）
     */
    public Stream<T> stream() {
        return list.stream();
    }

    /**
     * 获取并行流式处理对象（线程安全）
     * @return 并行元素流（Stream<T>）
     */
    public Stream<T> parallelStream() {
        return list.parallelStream();
    }

    /**
     * 转换为不可修改的列表（避免外部修改，线程安全）
     * @return 不可修改的 List<T>
     */
    public List<T> toUnmodifiableList() {
        return Collections.unmodifiableList(list);
    }

    // ------------------------------ 全局列表管理 ------------------------------

    /**
     * 彻底删除指定 key 的全局列表（从全局容器中移除实例）
     * @param key 要删除的列表标识
     */
    public static void removeGlobalList(String key) {
        if (key != null) {
            GLOBAL_LISTS.remove(key);
        }
    }

    /**
     * 检查指定 key 的全局列表是否存在
     * @param key 列表标识
     * @return 存在返回 true
     */
    public static boolean exists(String key) {
        return key != null && GLOBAL_LISTS.containsKey(key);
    }

    /**
     * 获取当前所有全局列表的 key 集合（线程安全）
     * @return 不可修改的 key 集合
     */
    public static Set<String> getAllKeys() {
        return Collections.unmodifiableSet(GLOBAL_LISTS.keySet());
    }
}